/**************************************************
beginning of licensing agreement
Microsoft Public License (Ms-PL)

This license governs use of the accompanying software. If you use the software, you accept this license. If you do not accept the license, do not use the software.

1. Definitions

The terms "reproduce," "reproduction," "derivative works," and "distribution" have the same meaning here as under U.S. copyright law.

A "contribution" is the original software, or any additions or changes to the software.

A "contributor" is any person that distributes its contribution under this license.

"Licensed patents" are a contributor's patent claims that read directly on its contribution.

2. Grant of Rights

(A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create.

(B) Patent Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or otherwise dispose of its contribution in the software or derivative works of the contribution in the software.

3. Conditions and Limitations

(A) No Trademark License- This license does not grant you rights to use any contributors' name, logo, or trademarks.

(B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, your patent license from such contributor to the software ends automatically.

(C) If you distribute any portion of the software, you must retain all copyright, patent, trademark, and attribution notices that are present in the software.

(D) If you distribute any portion of the software in source code form, you may do so only under this license by including a complete copy of this license with your distribution. If you distribute any portion of the software in compiled or object code form, you may only do so under a license that complies with this license.

(E) The software is licensed "as-is." You bear the risk of using it. The contributors give no express warranties, guarantees or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent permitted under your local laws, the contributors exclude the implied warranties of merchantability, fitness for a particular purpose and non-infringement. 
end of licensing agreement
**************************************************/
//------------------------------------------------------------------------------
// <autogenerated>
//     This code was generated by a tool.
//     Runtime Version: 1.1.4322.573
//
//     Changes to this file may cause incorrect behavior and will be lost if 
//     the code is regenerated.
// </autogenerated>
//------------------------------------------------------------------------------

// 
// This source code was auto-generated by xsd, Version=1.1.4322.573.
// 
namespace PssdiagCustomDiagSchema.Namespace {
    using System;
    using System.Data;
    using System.Xml;
    using System.Runtime.Serialization;
    
    
    [Serializable()]
    [System.ComponentModel.DesignerCategoryAttribute("code")]
    [System.Diagnostics.DebuggerStepThrough()]
    [System.ComponentModel.ToolboxItem(true)]
    public class CustomTasks : DataSet {
        
        private CustomTaskDataTable tableCustomTask;
        
        private ParamDataTable tableParam;
        
        private DataRelation relationCustomTask_Param;
        
        public CustomTasks() {
            this.InitClass();
            System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
            this.Tables.CollectionChanged += schemaChangedHandler;
            this.Relations.CollectionChanged += schemaChangedHandler;
        }
        
        protected CustomTasks(SerializationInfo info, StreamingContext context) {
            string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
            if ((strSchema != null)) {
                DataSet ds = new DataSet();
                ds.ReadXmlSchema(new XmlTextReader(new System.IO.StringReader(strSchema)));
                if ((ds.Tables["CustomTask"] != null)) {
                    this.Tables.Add(new CustomTaskDataTable(ds.Tables["CustomTask"]));
                }
                if ((ds.Tables["Param"] != null)) {
                    this.Tables.Add(new ParamDataTable(ds.Tables["Param"]));
                }
                this.DataSetName = ds.DataSetName;
                this.Prefix = ds.Prefix;
                this.Namespace = ds.Namespace;
                this.Locale = ds.Locale;
                this.CaseSensitive = ds.CaseSensitive;
                this.EnforceConstraints = ds.EnforceConstraints;
                this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
                this.InitVars();
            }
            else {
                this.InitClass();
            }
            this.GetSerializationData(info, context);
            System.ComponentModel.CollectionChangeEventHandler schemaChangedHandler = new System.ComponentModel.CollectionChangeEventHandler(this.SchemaChanged);
            this.Tables.CollectionChanged += schemaChangedHandler;
            this.Relations.CollectionChanged += schemaChangedHandler;
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public CustomTaskDataTable CustomTask {
            get {
                return this.tableCustomTask;
            }
        }
        
        [System.ComponentModel.Browsable(false)]
        [System.ComponentModel.DesignerSerializationVisibilityAttribute(System.ComponentModel.DesignerSerializationVisibility.Content)]
        public ParamDataTable Param {
            get {
                return this.tableParam;
            }
        }
        
        public override DataSet Clone() {
            CustomTasks cln = ((CustomTasks)(base.Clone()));
            cln.InitVars();
            return cln;
        }
        
        protected override bool ShouldSerializeTables() {
            return false;
        }
        
        protected override bool ShouldSerializeRelations() {
            return false;
        }
        
        protected override void ReadXmlSerializable(XmlReader reader) {
            this.Reset();
            DataSet ds = new DataSet();
            ds.ReadXml(reader);
            if ((ds.Tables["CustomTask"] != null)) {
                this.Tables.Add(new CustomTaskDataTable(ds.Tables["CustomTask"]));
            }
            if ((ds.Tables["Param"] != null)) {
                this.Tables.Add(new ParamDataTable(ds.Tables["Param"]));
            }
            this.DataSetName = ds.DataSetName;
            this.Prefix = ds.Prefix;
            this.Namespace = ds.Namespace;
            this.Locale = ds.Locale;
            this.CaseSensitive = ds.CaseSensitive;
            this.EnforceConstraints = ds.EnforceConstraints;
            this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
            this.InitVars();
        }
        
        protected override System.Xml.Schema.XmlSchema GetSchemaSerializable() {
            System.IO.MemoryStream stream = new System.IO.MemoryStream();
            this.WriteXmlSchema(new XmlTextWriter(stream, null));
            stream.Position = 0;
            return System.Xml.Schema.XmlSchema.Read(new XmlTextReader(stream), null);
        }
        
        internal void InitVars() {
            this.tableCustomTask = ((CustomTaskDataTable)(this.Tables["CustomTask"]));
            if ((this.tableCustomTask != null)) {
                this.tableCustomTask.InitVars();
            }
            this.tableParam = ((ParamDataTable)(this.Tables["Param"]));
            if ((this.tableParam != null)) {
                this.tableParam.InitVars();
            }
            this.relationCustomTask_Param = this.Relations["CustomTask_Param"];
        }
        
        private void InitClass() {
            this.DataSetName = "CustomTasks";
            this.Prefix = "";
            this.Namespace = "http://tempuri.org/CustomDiag.xsd";
            this.Locale = new System.Globalization.CultureInfo("en-US");
            this.CaseSensitive = false;
            this.EnforceConstraints = false;
            this.tableCustomTask = new CustomTaskDataTable();
            this.Tables.Add(this.tableCustomTask);
            this.tableParam = new ParamDataTable();
            this.Tables.Add(this.tableParam);
            ForeignKeyConstraint fkc;
            fkc = new ForeignKeyConstraint("CustomTask_Param", new DataColumn[] {
                        this.tableCustomTask.CustomTask_IdColumn}, new DataColumn[] {
                        this.tableParam.CustomTask_IdColumn});
            this.tableParam.Constraints.Add(fkc);
            fkc.AcceptRejectRule = System.Data.AcceptRejectRule.None;
            fkc.DeleteRule = System.Data.Rule.Cascade;
            fkc.UpdateRule = System.Data.Rule.Cascade;
            this.relationCustomTask_Param = new DataRelation("CustomTask_Param", new DataColumn[] {
                        this.tableCustomTask.CustomTask_IdColumn}, new DataColumn[] {
                        this.tableParam.CustomTask_IdColumn}, false);
            this.relationCustomTask_Param.Nested = true;
            this.Relations.Add(this.relationCustomTask_Param);
        }
        
        private bool ShouldSerializeCustomTask() {
            return false;
        }
        
        private bool ShouldSerializeParam() {
            return false;
        }
        
        private void SchemaChanged(object sender, System.ComponentModel.CollectionChangeEventArgs e) {
            if ((e.Action == System.ComponentModel.CollectionChangeAction.Remove)) {
                this.InitVars();
            }
        }
        
        public delegate void CustomTaskRowChangeEventHandler(object sender, CustomTaskRowChangeEvent e);
        
        public delegate void ParamRowChangeEventHandler(object sender, ParamRowChangeEvent e);
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class CustomTaskDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnenabled;
            
            private DataColumn columngroupname;
            
            private DataColumn columntaskname;
            
            private DataColumn columntype;
            
            private DataColumn columnpoint;
            
            private DataColumn columnwait;
            
            private DataColumn columncmd;
            
            private DataColumn columnpollinginterval;
            
            private DataColumn columnCustomTask_Id;
            
            internal CustomTaskDataTable() : 
                    base("CustomTask") {
                this.InitClass();
            }
            
            internal CustomTaskDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn enabledColumn {
                get {
                    return this.columnenabled;
                }
            }
            
            internal DataColumn groupnameColumn {
                get {
                    return this.columngroupname;
                }
            }
            
            internal DataColumn tasknameColumn {
                get {
                    return this.columntaskname;
                }
            }
            
            internal DataColumn typeColumn {
                get {
                    return this.columntype;
                }
            }
            
            internal DataColumn pointColumn {
                get {
                    return this.columnpoint;
                }
            }
            
            internal DataColumn waitColumn {
                get {
                    return this.columnwait;
                }
            }
            
            internal DataColumn cmdColumn {
                get {
                    return this.columncmd;
                }
            }
            
            internal DataColumn pollingintervalColumn {
                get {
                    return this.columnpollinginterval;
                }
            }
            
            internal DataColumn CustomTask_IdColumn {
                get {
                    return this.columnCustomTask_Id;
                }
            }
            
            public CustomTaskRow this[int index] {
                get {
                    return ((CustomTaskRow)(this.Rows[index]));
                }
            }
            
            public event CustomTaskRowChangeEventHandler CustomTaskRowChanged;
            
            public event CustomTaskRowChangeEventHandler CustomTaskRowChanging;
            
            public event CustomTaskRowChangeEventHandler CustomTaskRowDeleted;
            
            public event CustomTaskRowChangeEventHandler CustomTaskRowDeleting;
            
            public void AddCustomTaskRow(CustomTaskRow row) {
                this.Rows.Add(row);
            }
            
            public CustomTaskRow AddCustomTaskRow(bool enabled, string groupname, string taskname, string type, string point, string wait, string cmd, int pollinginterval) {
                CustomTaskRow rowCustomTaskRow = ((CustomTaskRow)(this.NewRow()));
                rowCustomTaskRow.ItemArray = new object[] {
                        enabled,
                        groupname,
                        taskname,
                        type,
                        point,
                        wait,
                        cmd,
                        pollinginterval,
                        null};
                this.Rows.Add(rowCustomTaskRow);
                return rowCustomTaskRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                CustomTaskDataTable cln = ((CustomTaskDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new CustomTaskDataTable();
            }
            
            internal void InitVars() {
                this.columnenabled = this.Columns["enabled"];
                this.columngroupname = this.Columns["groupname"];
                this.columntaskname = this.Columns["taskname"];
                this.columntype = this.Columns["type"];
                this.columnpoint = this.Columns["point"];
                this.columnwait = this.Columns["wait"];
                this.columncmd = this.Columns["cmd"];
                this.columnpollinginterval = this.Columns["pollinginterval"];
                this.columnCustomTask_Id = this.Columns["CustomTask_Id"];
            }
            
            private void InitClass() {
                this.columnenabled = new DataColumn("enabled", typeof(bool), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnenabled);
                this.columngroupname = new DataColumn("groupname", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columngroupname);
                this.columntaskname = new DataColumn("taskname", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columntaskname);
                this.columntype = new DataColumn("type", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columntype);
                this.columnpoint = new DataColumn("point", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnpoint);
                this.columnwait = new DataColumn("wait", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnwait);
                this.columncmd = new DataColumn("cmd", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columncmd);
                this.columnpollinginterval = new DataColumn("pollinginterval", typeof(int), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnpollinginterval);
                this.columnCustomTask_Id = new DataColumn("CustomTask_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnCustomTask_Id);
                this.Constraints.Add(new UniqueConstraint("Constraint1", new DataColumn[] {
                                this.columnCustomTask_Id}, true));
                this.columnenabled.Namespace = "";
                this.columngroupname.Namespace = "";
                this.columntaskname.Namespace = "";
                this.columntype.Namespace = "";
                this.columnpoint.Namespace = "";
                this.columnwait.Namespace = "";
                this.columncmd.Namespace = "";
                this.columnpollinginterval.Namespace = "";
                this.columnCustomTask_Id.AutoIncrement = true;
                this.columnCustomTask_Id.AllowDBNull = false;
                this.columnCustomTask_Id.Unique = true;
            }
            
            public CustomTaskRow NewCustomTaskRow() {
                return ((CustomTaskRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new CustomTaskRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(CustomTaskRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.CustomTaskRowChanged != null)) {
                    this.CustomTaskRowChanged(this, new CustomTaskRowChangeEvent(((CustomTaskRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.CustomTaskRowChanging != null)) {
                    this.CustomTaskRowChanging(this, new CustomTaskRowChangeEvent(((CustomTaskRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.CustomTaskRowDeleted != null)) {
                    this.CustomTaskRowDeleted(this, new CustomTaskRowChangeEvent(((CustomTaskRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.CustomTaskRowDeleting != null)) {
                    this.CustomTaskRowDeleting(this, new CustomTaskRowChangeEvent(((CustomTaskRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveCustomTaskRow(CustomTaskRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class CustomTaskRow : DataRow {
            
            private CustomTaskDataTable tableCustomTask;
            
            internal CustomTaskRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableCustomTask = ((CustomTaskDataTable)(this.Table));
            }
            
            public bool enabled {
                get {
                    try {
                        return ((bool)(this[this.tableCustomTask.enabledColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCustomTask.enabledColumn] = value;
                }
            }
            
            public string groupname {
                get {
                    try {
                        return ((string)(this[this.tableCustomTask.groupnameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCustomTask.groupnameColumn] = value;
                }
            }
            
            public string taskname {
                get {
                    try {
                        return ((string)(this[this.tableCustomTask.tasknameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCustomTask.tasknameColumn] = value;
                }
            }
            
            public string type {
                get {
                    try {
                        return ((string)(this[this.tableCustomTask.typeColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCustomTask.typeColumn] = value;
                }
            }
            
            public string point {
                get {
                    try {
                        return ((string)(this[this.tableCustomTask.pointColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCustomTask.pointColumn] = value;
                }
            }
            
            public string wait {
                get {
                    try {
                        return ((string)(this[this.tableCustomTask.waitColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCustomTask.waitColumn] = value;
                }
            }
            
            public string cmd {
                get {
                    try {
                        return ((string)(this[this.tableCustomTask.cmdColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCustomTask.cmdColumn] = value;
                }
            }
            
            public int pollinginterval {
                get {
                    try {
                        return ((int)(this[this.tableCustomTask.pollingintervalColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableCustomTask.pollingintervalColumn] = value;
                }
            }
            
            public bool IsenabledNull() {
                return this.IsNull(this.tableCustomTask.enabledColumn);
            }
            
            public void SetenabledNull() {
                this[this.tableCustomTask.enabledColumn] = System.Convert.DBNull;
            }
            
            public bool IsgroupnameNull() {
                return this.IsNull(this.tableCustomTask.groupnameColumn);
            }
            
            public void SetgroupnameNull() {
                this[this.tableCustomTask.groupnameColumn] = System.Convert.DBNull;
            }
            
            public bool IstasknameNull() {
                return this.IsNull(this.tableCustomTask.tasknameColumn);
            }
            
            public void SettasknameNull() {
                this[this.tableCustomTask.tasknameColumn] = System.Convert.DBNull;
            }
            
            public bool IstypeNull() {
                return this.IsNull(this.tableCustomTask.typeColumn);
            }
            
            public void SettypeNull() {
                this[this.tableCustomTask.typeColumn] = System.Convert.DBNull;
            }
            
            public bool IspointNull() {
                return this.IsNull(this.tableCustomTask.pointColumn);
            }
            
            public void SetpointNull() {
                this[this.tableCustomTask.pointColumn] = System.Convert.DBNull;
            }
            
            public bool IswaitNull() {
                return this.IsNull(this.tableCustomTask.waitColumn);
            }
            
            public void SetwaitNull() {
                this[this.tableCustomTask.waitColumn] = System.Convert.DBNull;
            }
            
            public bool IscmdNull() {
                return this.IsNull(this.tableCustomTask.cmdColumn);
            }
            
            public void SetcmdNull() {
                this[this.tableCustomTask.cmdColumn] = System.Convert.DBNull;
            }
            
            public bool IspollingintervalNull() {
                return this.IsNull(this.tableCustomTask.pollingintervalColumn);
            }
            
            public void SetpollingintervalNull() {
                this[this.tableCustomTask.pollingintervalColumn] = System.Convert.DBNull;
            }
            
            public ParamRow[] GetParamRows() {
                return ((ParamRow[])(this.GetChildRows(this.Table.ChildRelations["CustomTask_Param"])));
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class CustomTaskRowChangeEvent : EventArgs {
            
            private CustomTaskRow eventRow;
            
            private DataRowAction eventAction;
            
            public CustomTaskRowChangeEvent(CustomTaskRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public CustomTaskRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class ParamDataTable : DataTable, System.Collections.IEnumerable {
            
            private DataColumn columnname;
            
            private DataColumn columnprompt;
            
            private DataColumn columndatatype;
            
            private DataColumn column_default;
            
            private DataColumn columnCustomTask_Id;
            
            internal ParamDataTable() : 
                    base("Param") {
                this.InitClass();
            }
            
            internal ParamDataTable(DataTable table) : 
                    base(table.TableName) {
                if ((table.CaseSensitive != table.DataSet.CaseSensitive)) {
                    this.CaseSensitive = table.CaseSensitive;
                }
                if ((table.Locale.ToString() != table.DataSet.Locale.ToString())) {
                    this.Locale = table.Locale;
                }
                if ((table.Namespace != table.DataSet.Namespace)) {
                    this.Namespace = table.Namespace;
                }
                this.Prefix = table.Prefix;
                this.MinimumCapacity = table.MinimumCapacity;
                this.DisplayExpression = table.DisplayExpression;
            }
            
            [System.ComponentModel.Browsable(false)]
            public int Count {
                get {
                    return this.Rows.Count;
                }
            }
            
            internal DataColumn nameColumn {
                get {
                    return this.columnname;
                }
            }
            
            internal DataColumn promptColumn {
                get {
                    return this.columnprompt;
                }
            }
            
            internal DataColumn datatypeColumn {
                get {
                    return this.columndatatype;
                }
            }
            
            internal DataColumn _defaultColumn {
                get {
                    return this.column_default;
                }
            }
            
            internal DataColumn CustomTask_IdColumn {
                get {
                    return this.columnCustomTask_Id;
                }
            }
            
            public ParamRow this[int index] {
                get {
                    return ((ParamRow)(this.Rows[index]));
                }
            }
            
            public event ParamRowChangeEventHandler ParamRowChanged;
            
            public event ParamRowChangeEventHandler ParamRowChanging;
            
            public event ParamRowChangeEventHandler ParamRowDeleted;
            
            public event ParamRowChangeEventHandler ParamRowDeleting;
            
            public void AddParamRow(ParamRow row) {
                this.Rows.Add(row);
            }
            
            public ParamRow AddParamRow(string name, string prompt, string datatype, string _default, CustomTaskRow parentCustomTaskRowByCustomTask_Param) {
                ParamRow rowParamRow = ((ParamRow)(this.NewRow()));
                rowParamRow.ItemArray = new object[] {
                        name,
                        prompt,
                        datatype,
                        _default,
                        parentCustomTaskRowByCustomTask_Param[8]};
                this.Rows.Add(rowParamRow);
                return rowParamRow;
            }
            
            public System.Collections.IEnumerator GetEnumerator() {
                return this.Rows.GetEnumerator();
            }
            
            public override DataTable Clone() {
                ParamDataTable cln = ((ParamDataTable)(base.Clone()));
                cln.InitVars();
                return cln;
            }
            
            protected override DataTable CreateInstance() {
                return new ParamDataTable();
            }
            
            internal void InitVars() {
                this.columnname = this.Columns["name"];
                this.columnprompt = this.Columns["prompt"];
                this.columndatatype = this.Columns["datatype"];
                this.column_default = this.Columns["default"];
                this.columnCustomTask_Id = this.Columns["CustomTask_Id"];
            }
            
            private void InitClass() {
                this.columnname = new DataColumn("name", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnname);
                this.columnprompt = new DataColumn("prompt", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columnprompt);
                this.columndatatype = new DataColumn("datatype", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.columndatatype);
                this.column_default = new DataColumn("default", typeof(string), null, System.Data.MappingType.Attribute);
                this.Columns.Add(this.column_default);
                this.columnCustomTask_Id = new DataColumn("CustomTask_Id", typeof(int), null, System.Data.MappingType.Hidden);
                this.Columns.Add(this.columnCustomTask_Id);
                this.columnname.Namespace = "";
                this.columnprompt.Namespace = "";
                this.columndatatype.Namespace = "";
                this.column_default.Namespace = "";
            }
            
            public ParamRow NewParamRow() {
                return ((ParamRow)(this.NewRow()));
            }
            
            protected override DataRow NewRowFromBuilder(DataRowBuilder builder) {
                return new ParamRow(builder);
            }
            
            protected override System.Type GetRowType() {
                return typeof(ParamRow);
            }
            
            protected override void OnRowChanged(DataRowChangeEventArgs e) {
                base.OnRowChanged(e);
                if ((this.ParamRowChanged != null)) {
                    this.ParamRowChanged(this, new ParamRowChangeEvent(((ParamRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowChanging(DataRowChangeEventArgs e) {
                base.OnRowChanging(e);
                if ((this.ParamRowChanging != null)) {
                    this.ParamRowChanging(this, new ParamRowChangeEvent(((ParamRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleted(DataRowChangeEventArgs e) {
                base.OnRowDeleted(e);
                if ((this.ParamRowDeleted != null)) {
                    this.ParamRowDeleted(this, new ParamRowChangeEvent(((ParamRow)(e.Row)), e.Action));
                }
            }
            
            protected override void OnRowDeleting(DataRowChangeEventArgs e) {
                base.OnRowDeleting(e);
                if ((this.ParamRowDeleting != null)) {
                    this.ParamRowDeleting(this, new ParamRowChangeEvent(((ParamRow)(e.Row)), e.Action));
                }
            }
            
            public void RemoveParamRow(ParamRow row) {
                this.Rows.Remove(row);
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class ParamRow : DataRow {
            
            private ParamDataTable tableParam;
            
            internal ParamRow(DataRowBuilder rb) : 
                    base(rb) {
                this.tableParam = ((ParamDataTable)(this.Table));
            }
            
            public string name {
                get {
                    try {
                        return ((string)(this[this.tableParam.nameColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableParam.nameColumn] = value;
                }
            }
            
            public string prompt {
                get {
                    try {
                        return ((string)(this[this.tableParam.promptColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableParam.promptColumn] = value;
                }
            }
            
            public string datatype {
                get {
                    try {
                        return ((string)(this[this.tableParam.datatypeColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableParam.datatypeColumn] = value;
                }
            }
            
            public string _default {
                get {
                    try {
                        return ((string)(this[this.tableParam._defaultColumn]));
                    }
                    catch (InvalidCastException e) {
                        throw new StrongTypingException("Cannot get value because it is DBNull.", e);
                    }
                }
                set {
                    this[this.tableParam._defaultColumn] = value;
                }
            }
            
            public CustomTaskRow CustomTaskRow {
                get {
                    return ((CustomTaskRow)(this.GetParentRow(this.Table.ParentRelations["CustomTask_Param"])));
                }
                set {
                    this.SetParentRow(value, this.Table.ParentRelations["CustomTask_Param"]);
                }
            }
            
            public bool IsnameNull() {
                return this.IsNull(this.tableParam.nameColumn);
            }
            
            public void SetnameNull() {
                this[this.tableParam.nameColumn] = System.Convert.DBNull;
            }
            
            public bool IspromptNull() {
                return this.IsNull(this.tableParam.promptColumn);
            }
            
            public void SetpromptNull() {
                this[this.tableParam.promptColumn] = System.Convert.DBNull;
            }
            
            public bool IsdatatypeNull() {
                return this.IsNull(this.tableParam.datatypeColumn);
            }
            
            public void SetdatatypeNull() {
                this[this.tableParam.datatypeColumn] = System.Convert.DBNull;
            }
            
            public bool Is_defaultNull() {
                return this.IsNull(this.tableParam._defaultColumn);
            }
            
            public void Set_defaultNull() {
                this[this.tableParam._defaultColumn] = System.Convert.DBNull;
            }
        }
        
        [System.Diagnostics.DebuggerStepThrough()]
        public class ParamRowChangeEvent : EventArgs {
            
            private ParamRow eventRow;
            
            private DataRowAction eventAction;
            
            public ParamRowChangeEvent(ParamRow row, DataRowAction action) {
                this.eventRow = row;
                this.eventAction = action;
            }
            
            public ParamRow Row {
                get {
                    return this.eventRow;
                }
            }
            
            public DataRowAction Action {
                get {
                    return this.eventAction;
                }
            }
        }
    }
}
